Virtual machines are abstract computers that allow for portability of software applications between different underlying computer architectures. Typically, the virtual machine (VM) is a complex software product that is implemented upon a particular computer hardware platform and/or operating system. The VM then provides a uniform layer of abstraction between the hardware platform and any compiled software applications that will run thereon. Virtual machines are essential for the portability of certain technologies, including Java. The Java Virtual Machine (JVM) allows compiled Java programs to be run on the JVM, independently of whatever hardware or operating system may be underneath. Examples of commercially available JVMs include the Sun Java Virtual Machine from Sun Microsystems, Inc., and the JRockit Virtual Machine from BEA Systems, Inc.
Virtual machines for languages such as Java, C#, Perl and Lisp include garbage collection features as part of the VM itself. Garbage collection allows the VM to reclaim unused computer memory during runtime, and is an important feature for the VM, since it relieves the programmer from much of the burden in providing for and managing memory cleanup within the software application itself. The basic concept of garbage collection is to find all of the data that is currently reachable from the software application, and then discard all other data. To release the memory used for a software object, the programmer only has to erase any pointer pointing to that object. The garbage collection logic or routines (also referred to as the garbage collector) will later detect that the object is no longer reachable, and will reclaim the memory.
Traditionally, in the Java environment, during garbage collection the garbage collector pauses the running JVM and performs the necessary work. This is referred to as the garbage collector pause time, or simply the pause time. The pause time can cause problems for the programmer since it is difficult when preparing application code to anticipate for random pauses. JVMs with unpredictable pause times cannot be used for applications with strict timing requirements, such as real-time systems for telecommunications, physical processes or warning systems. Applications with more relaxed requirements, such as interactive applications, can still seem to fail if they do not respond to the user within an expected time frame.
Much work has been done to improve the pause times for garbage collectors. For example, the pause time can be shortened by running the garbage collecting threads in parallel on multiple processors during the pause. The garbage collecting process can also be designed to be a generational one, in which case it is divided into a young collection (YC) phase that is performed often, and an old collection (OC) phase that is performed more seldom. Also, parts of the garbage collection process can be performed concurrently with the running software application, with short pauses to accommodate for changes performed by the running application.
As described above, the current techniques used for garbage collection are unsatisfactory in environments and software applications that require strict timing, such as telecommunications, warning systems, and other real-time systems. What is desirable is a garbage collection technique that can enable predictable and short pause times within a virtual machine.